home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 07 - 1991 / Goodies Disk / Glypha.src / Code ƒ / H-Initialize.p < prev    next >
Encoding:
Text File  |  1991-02-06  |  17.0 KB  |  487 lines  |  [TEXT/PJMM]
  1. {This code was written by John Calhoun of Soft Dorothy Software.  Code is ©1990 john calhoun}
  2. {Feel free to read over the code, learn from it, etc.}
  3. {If the code helps you or if you borrow portions of it, please send $15 to:}
  4. {john calhoun}
  5. {1201 Oread #4}
  6. {Lawrence, KS 66044}
  7. {So long as this header remains, feel free to distribute this code.}
  8.  
  9. unit Initialize;
  10.  
  11. interface
  12.     uses
  13.         Sound, GameUtils, Enemies, GlyphaGuts;
  14.  
  15.     procedure Init_My_Menus;
  16.     function NewBitMap (var theBitMap: BitMap; theRect: Rect): Ptr;
  17.     procedure InitVariables;
  18.  
  19. implementation
  20.  
  21. {=================================}
  22.  
  23.     procedure Init_My_Menus;
  24.         const
  25.             Menu1 = 201;                {Menu resource ID}
  26.             Menu2 = 202;                {Menu resource ID}
  27.             Menu3 = 203;                {Menu resource ID}
  28.     begin
  29.         ClearMenuBar;                            {Clear any old menu bars}
  30.         AppleMenu := GetMenu(Menu1);        {Get the menu from the resource file}
  31.         AddResMenu(AppleMenu, 'DRVR');    {Add in DAs}
  32.         InsertMenu(AppleMenu, 0);            {Insert this menu into the menu bar}
  33.         GameMenu := GetMenu(Menu2);        {Get the menu from the resource file}
  34.         InsertMenu(GameMenu, 0);                {Insert this menu into the menu bar}
  35.         OptionsMenu := GetMenu(Menu3);        {Get the menu from the resource file}
  36.         InsertMenu(OptionsMenu, 0);            {Insert this menu into the menu bar}
  37.         DisableItem(GameMenu, 2);
  38.         DisableItem(GameMenu, 3);
  39.         DrawMenuBar;
  40.     end;
  41.  
  42. {=================================}
  43.  
  44.     function NewBitMap;
  45.     begin
  46.         with theBitMap, theRect do
  47.             begin
  48.                 rowBytes := ((right - left + 15) div 16) * 2;
  49.                 baseAddr := NewPtr(rowBytes * (bottom - top));
  50.                 bounds := theRect;
  51.                 if MemError <> noErr then
  52.                     begin
  53.                         NewBitMap := nil
  54.                     end
  55.                 else
  56.                     NewBitMap := baseAddr;
  57.             end;
  58.     end;
  59.  
  60. {=================================}
  61.  
  62.     procedure InitVariables;
  63.         var
  64.             index, index2: Integer;
  65.             rawPointer: Ptr;
  66.             Pic_Handle: PicHandle;
  67.             theSnd: Handle;
  68.             tempRect: Rect;
  69.     begin
  70.         numberOfStones := 4;
  71.         levelStart := 1;
  72.         levelOn := 0;
  73.         mortalsStart := defaultNum;
  74.         chanPtr := nil;
  75.         ahnkCursor := GetCursor(5000);
  76.         playMask := MDownMask + MUpMask + KeyDownMask;
  77.         GetDateTime(RandSeed);
  78.         playing := FALSE;
  79.         pausing := FALSE;
  80.  
  81.         rawPointer := NewPtr(SizeOf(GrafPort));    {Initialize and setup offscreen virgin console}
  82.         offVirginPort := GrafPtr(rawPointer);
  83.         OpenPort(offVirginPort);
  84.         SetRect(offVirginArea, 0, 0, 512, 342);
  85.         offVirginBits := NewBitMap(offVirginMap, offVirginArea);
  86.         SetPortBits(offVirginMap);
  87.         EraseRect(offVirginMap.bounds);
  88.         Pic_Handle := GetPicture(1);                {Get Picture into memory}
  89.         if (Pic_Handle <> nil) then                {Only use handle if it is valid}
  90.             DrawPicture(Pic_Handle, offVirginArea);{Draw this picture}
  91.         ReleaseResource(Handle(Pic_Handle));
  92.  
  93.         rawPointer := NewPtr(SizeOf(GrafPort));    {Initialize and setup offscreen}
  94.         offLoadPort := GrafPtr(rawPointer);
  95.         OpenPort(offLoadPort);
  96.         SetRect(offLoadArea, 0, 0, 512, 342);
  97.         offLoadBits := NewBitMap(offLoadMap, offLoadArea);
  98.         SetPortBits(offLoadMap);
  99.         EraseRect(offLoadMap.bounds);
  100.  
  101.         rawPointer := NewPtr(SizeOf(GrafPort));    {Initialize and setup offscreen}
  102.         offPlayerPort := GrafPtr(rawPointer);
  103.         OpenPort(offPlayerPort);
  104.         SetRect(offPlayerArea, 0, 0, 512, 282);
  105.         offPlayerBits := NewBitMap(offPlayerMap, offPlayerArea);
  106.         SetPortBits(offPlayerMap);
  107.         EraseRect(offPlayerMap.bounds);
  108.         Pic_Handle := GetPicture(2);            {Get Picture into memory}
  109.         SetRect(tempRect, 0, 0, 512, 282);    {left,top,right,bottom}
  110.         if (Pic_Handle <> nil) then            {Only use handle if it is valid}
  111.             begin
  112.                 ClipRect(tempRect);                    {Clip picture to this rectangle}
  113.                 HLock(Handle(Pic_Handle));            {Lock the handle before using it}
  114.                 tempRect.Right := tempRect.Left + (Pic_Handle^^.picFrame.Right - Pic_Handle^^.picFrame.Left);
  115.                 tempRect.Bottom := tempRect.Top + (Pic_Handle^^.picFrame.Bottom - Pic_Handle^^.picFrame.Top);
  116.                 HUnLock(Handle(Pic_Handle));        {Unlock the picture again}
  117.             end;
  118.         if (Pic_Handle <> nil) then                {Only use handle if it is valid}
  119.             DrawPicture(Pic_Handle, tempRect);     {Draw this picture}
  120.         ReleaseResource(Handle(Pic_Handle));
  121.         SetRect(tempRect, 0, 0, 1023, 1023);     {Widen the clip area again}
  122.         ClipRect(tempRect);
  123.  
  124.         rawPointer := NewPtr(SizeOf(GrafPort));    {Initialize and setup offscreen}
  125.         offEnemyPort := GrafPtr(rawPointer);
  126.         OpenPort(offEnemyPort);
  127.         SetRect(offEnemyArea, 0, 0, 512, 285);
  128.         offEnemyBits := NewBitMap(offEnemyMap, offEnemyArea);
  129.         SetPortBits(offEnemyMap);
  130.         EraseRect(offEnemyMap.bounds);
  131.         SetPort(offEnemyPort);                {Set the port to my window}
  132.         Pic_Handle := GetPicture(3);            {Get Picture into memory}
  133.         SetRect(tempRect, 0, 0, 512, 285);        {left,top,right,bottom}
  134.         if (Pic_Handle <> nil) then            {Only use handle if it is valid}
  135.             begin
  136.                 ClipRect(tempRect);                {Clip picture to this rectangle}
  137.                 HLock(Handle(Pic_Handle));            {Lock the handle before using it}
  138.                 tempRect.Right := tempRect.Left + (Pic_Handle^^.picFrame.Right - Pic_Handle^^.picFrame.Left);
  139.                 tempRect.Bottom := tempRect.Top + (Pic_Handle^^.picFrame.Bottom - Pic_Handle^^.picFrame.Top);
  140.                 HUnLock(Handle(Pic_Handle));        {Unlock the picture again}
  141.             end;
  142.         if (Pic_Handle <> nil) then            {Only use handle if it is valid}
  143.             DrawPicture(Pic_Handle, tempRect);     {Draw this picture}
  144.         ReleaseResource(Handle(Pic_Handle));
  145.  
  146.         SetRect(playerRects[0, 0], 0, 0, 54, 51);                {Rects for player facing right    }
  147.         SetRect(playerRects[0, 1], 108, 0, 162, 51);
  148.         SetRect(playerRects[0, 2], 54, 0, 108, 51);
  149.         SetRect(playerRects[0, 3], 108, 0, 162, 51);
  150.         SetRect(playerRects[0, 4], 162, 10, 217, 49);
  151.         SetRect(playerRects[0, 5], 217, 10, 272, 49);
  152.         SetRect(playerRects[1, 0], 218, 104, 272, 155);    {Rects for player facing left    }
  153.         SetRect(playerRects[1, 1], 110, 104, 164, 155);
  154.         SetRect(playerRects[1, 2], 164, 104, 216, 155);
  155.         SetRect(playerRects[1, 3], 110, 104, 164, 155);
  156.         SetRect(playerRects[1, 4], 55, 114, 110, 153);
  157.         SetRect(playerRects[1, 5], 0, 114, 55, 153);
  158.  
  159.         SetRect(playerRects[2, 0], 0, 52, 54, 103);            {These are masks for above    }
  160.         SetRect(playerRects[2, 1], 108, 52, 162, 103);
  161.         SetRect(playerRects[2, 2], 54, 52, 108, 103);
  162.         SetRect(playerRects[2, 3], 108, 52, 162, 103);
  163.         SetRect(playerRects[2, 4], 162, 62, 217, 101);
  164.         SetRect(playerRects[2, 5], 217, 62, 272, 101);
  165.  
  166.         SetRect(playerRects[3, 0], 218, 156, 272, 207);
  167.         SetRect(playerRects[3, 1], 110, 156, 164, 207);
  168.         SetRect(playerRects[3, 2], 164, 156, 218, 207);
  169.         SetRect(playerRects[3, 3], 110, 156, 164, 207);
  170.         SetRect(playerRects[3, 4], 55, 166, 110, 205);
  171.         SetRect(playerRects[3, 5], 0, 166, 55, 205);
  172.  
  173.         SetRect(boneRects[0, 6, 0], 411, 108, 459, 146);    {Falling skeleton left    }
  174.         SetRect(boneRects[0, 6, 1], 462, 108, 510, 146);    {It's mask                }
  175.         SetRect(boneRects[1, 6, 0], 410, 69, 458, 107);        {Falling skeleton right    }
  176.         SetRect(boneRects[1, 6, 1], 461, 69, 509, 107);        {It's mask                }
  177.         SetRect(boneRects[0, 7, 0], 462, 191, 506, 214);    {Pile of bones - left        }
  178.         SetRect(boneRects[0, 7, 1], 462, 222, 506, 245);    {It's mask                }
  179.         SetRect(boneRects[1, 7, 0], 462, 191, 506, 214);    {Same bones for right    }
  180.         SetRect(boneRects[1, 7, 1], 462, 222, 506, 245);    {It's mask                }
  181.  
  182.         SetRect(enemyRects[0, 0, 0, 0], 289, 88, 331, 131);
  183.         SetRect(enemyRects[0, 1, 0, 0], 334, 88, 376, 131);
  184.         SetRect(enemyRects[0, 2, 0, 0], 379, 88, 421, 131);
  185.         SetRect(enemyRects[0, 3, 0, 0], 334, 88, 376, 131);
  186.         SetRect(enemyRects[0, 4, 0, 0], 0, 79, 68, 116);
  187.         SetRect(enemyRects[0, 5, 0, 0], 69, 79, 137, 116);
  188.         SetRect(enemyRects[1, 0, 0, 0], 289, 0, 331, 43);
  189.         SetRect(enemyRects[1, 1, 0, 0], 334, 0, 376, 43);
  190.         SetRect(enemyRects[1, 2, 0, 0], 379, 0, 421, 43);
  191.         SetRect(enemyRects[1, 3, 0, 0], 334, 0, 376, 43);
  192.         SetRect(enemyRects[1, 4, 0, 0], 0, 0, 68, 37);
  193.         SetRect(enemyRects[1, 5, 0, 0], 69, 0, 137, 37);
  194.         SetRect(enemyRects[2, 0, 0, 0], 289, 176, 331, 219);
  195.         SetRect(enemyRects[2, 1, 0, 0], 334, 176, 376, 219);
  196.         SetRect(enemyRects[2, 2, 0, 0], 379, 176, 421, 219);
  197.         SetRect(enemyRects[2, 3, 0, 0], 334, 176, 376, 219);
  198.         SetRect(enemyRects[2, 4, 0, 0], 0, 158, 68, 195);
  199.         SetRect(enemyRects[2, 5, 0, 0], 69, 158, 137, 195);
  200.         SetRect(enemyRects[0, 0, 1, 0], 0, 241, 42, 284);
  201.         SetRect(enemyRects[0, 1, 1, 0], 468, 88, 510, 131);
  202.         SetRect(enemyRects[0, 2, 1, 0], 423, 88, 465, 131);
  203.         SetRect(enemyRects[0, 3, 1, 0], 468, 88, 510, 131);
  204.         SetRect(enemyRects[0, 4, 1, 0], 207, 79, 275, 116);
  205.         SetRect(enemyRects[0, 5, 1, 0], 138, 79, 206, 116);
  206.         SetRect(enemyRects[1, 0, 1, 0], 43, 241, 85, 284);
  207.         SetRect(enemyRects[1, 1, 1, 0], 468, 0, 510, 43);
  208.         SetRect(enemyRects[1, 2, 1, 0], 423, 0, 465, 43);
  209.         SetRect(enemyRects[1, 3, 1, 0], 468, 0, 510, 43);
  210.         SetRect(enemyRects[1, 4, 1, 0], 207, 0, 275, 37);
  211.         SetRect(enemyRects[1, 5, 1, 0], 138, 0, 206, 37);
  212.         SetRect(enemyRects[2, 0, 1, 0], 86, 241, 128, 284);
  213.         SetRect(enemyRects[2, 1, 1, 0], 468, 176, 510, 219);
  214.         SetRect(enemyRects[2, 2, 1, 0], 423, 176, 465, 219);
  215.         SetRect(enemyRects[2, 3, 1, 0], 468, 176, 510, 219);
  216.         SetRect(enemyRects[2, 4, 1, 0], 207, 158, 275, 195);
  217.         SetRect(enemyRects[2, 5, 1, 0], 138, 158, 206, 195);
  218.  
  219.         SetRect(enemyRects[0, 0, 0, 1], 289, 132, 331, 175);
  220.         SetRect(enemyRects[0, 1, 0, 1], 334, 132, 376, 175);
  221.         SetRect(enemyRects[0, 2, 0, 1], 379, 132, 421, 175);
  222.         SetRect(enemyRects[0, 3, 0, 1], 334, 132, 376, 175);
  223.         SetRect(enemyRects[0, 4, 0, 1], 0, 117, 68, 154);
  224.         SetRect(enemyRects[0, 5, 0, 1], 69, 117, 137, 154);
  225.         SetRect(enemyRects[1, 0, 0, 1], 289, 44, 331, 87);
  226.         SetRect(enemyRects[1, 1, 0, 1], 334, 44, 376, 87);
  227.         SetRect(enemyRects[1, 2, 0, 1], 379, 44, 421, 87);
  228.         SetRect(enemyRects[1, 3, 0, 1], 334, 44, 376, 87);
  229.         SetRect(enemyRects[1, 4, 0, 1], 0, 42, 68, 79);
  230.         SetRect(enemyRects[1, 5, 0, 1], 69, 42, 137, 79);
  231.         SetRect(enemyRects[2, 0, 0, 1], 289, 220, 331, 263);
  232.         SetRect(enemyRects[2, 1, 0, 1], 334, 220, 376, 263);
  233.         SetRect(enemyRects[2, 2, 0, 1], 379, 220, 421, 263);
  234.         SetRect(enemyRects[2, 3, 0, 1], 334, 220, 376, 263);
  235.         SetRect(enemyRects[2, 4, 0, 1], 0, 201, 68, 238);
  236.         SetRect(enemyRects[2, 5, 0, 1], 69, 200, 137, 237);
  237.         SetRect(enemyRects[0, 0, 1, 1], 129, 241, 171, 285);
  238.         SetRect(enemyRects[0, 1, 1, 1], 468, 132, 510, 175);
  239.         SetRect(enemyRects[0, 2, 1, 1], 423, 132, 465, 175);
  240.         SetRect(enemyRects[0, 3, 1, 1], 468, 132, 510, 175);
  241.         SetRect(enemyRects[0, 4, 1, 1], 207, 117, 275, 154);
  242.         SetRect(enemyRects[0, 5, 1, 1], 138, 117, 206, 154);
  243.         SetRect(enemyRects[1, 0, 1, 1], 172, 241, 214, 284);
  244.         SetRect(enemyRects[1, 1, 1, 1], 468, 44, 510, 87);
  245.         SetRect(enemyRects[1, 2, 1, 1], 423, 44, 465, 87);
  246.         SetRect(enemyRects[1, 3, 1, 1], 468, 44, 510, 87);
  247.         SetRect(enemyRects[1, 4, 1, 1], 207, 42, 275, 79);
  248.         SetRect(enemyRects[1, 5, 1, 1], 138, 42, 206, 79);
  249.         SetRect(enemyRects[2, 0, 1, 1], 215, 241, 257, 284);
  250.         SetRect(enemyRects[2, 1, 1, 1], 468, 220, 510, 263);
  251.         SetRect(enemyRects[2, 2, 1, 1], 423, 220, 465, 263);
  252.         SetRect(enemyRects[2, 3, 1, 1], 468, 220, 510, 263);
  253.         SetRect(enemyRects[2, 4, 1, 1], 207, 200, 275, 237);
  254.         SetRect(enemyRects[2, 5, 1, 1], 138, 200, 206, 237);
  255.  
  256.         enemyLift[0] := -1;
  257.         enemyLift[1] := -2;
  258.         enemyLift[2] := -4;
  259.  
  260.         SetRect(handRects[0, 0], 274, 69, 340, 126);
  261.         SetRect(handRects[1, 0], 341, 77, 406, 126);
  262.         SetRect(handRects[0, 1], 274, 127, 340, 186);    {location of masks}
  263.         SetRect(handRects[1, 1], 341, 136, 406, 186);
  264.  
  265.         for index := 0 to 15 do
  266.             begin
  267.                 SetRect(ankRects[index, 0], index * 17 + 1, 209, index * 17 + 17, 234);
  268.                 SetRect(ankRects[index, 1], index * 17 + 1, 236, index * 17 + 17, 261);
  269.             end;
  270.  
  271.         for index := 0 to 1 do
  272.             for index2 := 0 to 5 do
  273.                 SetRect(absoluteRects[index, index2], 0, 0, playerRects[index, index2].right - playerRects[index, index2].left, playerRects[index, index2].bottom - playerRects[index, index2].top);
  274.  
  275.         running[-16, 0, 0] := -14;    {new hori velocity}
  276.         running[-16, 0, 1] := 1;        {bird leg mode}
  277.         running[-15, 0, 0] := -13;
  278.         running[-15, 0, 1] := 1;
  279.         running[-14, 0, 0] := -12;
  280.         running[-14, 0, 1] := 1;
  281.         running[-13, 0, 0] := -11;
  282.         running[-13, 0, 1] := 1;
  283.         running[-12, 0, 0] := -10;
  284.         running[-12, 0, 1] := 1;
  285.         running[-11, 0, 0] := -9;
  286.         running[-11, 0, 1] := 1;
  287.         running[-10, 0, 0] := -8;
  288.         running[-10, 0, 1] := 1;
  289.         running[-9, 0, 0] := -7;
  290.         running[-9, 0, 1] := 1;
  291.         running[-8, 0, 0] := -6;
  292.         running[-8, 0, 1] := 1;
  293.         running[-7, 0, 0] := -5;
  294.         running[-7, 0, 1] := 1;
  295.         running[-6, 0, 0] := -4;
  296.         running[-6, 0, 1] := 1;
  297.         running[-5, 0, 0] := -3;
  298.         running[-5, 0, 1] := 1;
  299.         running[-4, 0, 0] := -2;
  300.         running[-4, 0, 1] := 1;
  301.         running[-3, 0, 0] := -1;
  302.         running[-3, 0, 1] := 1;
  303.         running[-2, 0, 0] := 0;
  304.         running[-2, 0, 1] := 1;
  305.         running[-1, 0, 0] := 1;
  306.         running[-1, 0, 1] := 1;
  307.         running[0, 0, 0] := 4;
  308.         running[0, 0, 1] := 0;
  309.         running[1, 0, 0] := 4;
  310.         running[1, 0, 1] := 0;
  311.         running[2, 0, 0] := 4;
  312.         running[2, 0, 1] := 0;
  313.         running[3, 0, 0] := 12;
  314.         running[3, 0, 1] := 3;
  315.         running[4, 0, 0] := 11;
  316.         running[4, 0, 1] := 1;
  317.         running[5, 0, 0] := 4;
  318.         running[5, 0, 1] := 0;
  319.         running[6, 0, 0] := 4;
  320.         running[6, 0, 1] := 0;
  321.         running[7, 0, 0] := 4;
  322.         running[7, 0, 1] := 0;
  323.         running[8, 0, 0] := 12;
  324.         running[8, 0, 1] := 3;
  325.         running[9, 0, 0] := 12;
  326.         running[9, 0, 1] := 3;
  327.         running[10, 0, 0] := 12;
  328.         running[10, 0, 1] := 3;
  329.         running[11, 0, 0] := 3;
  330.         running[11, 0, 1] := 2;
  331.         running[12, 0, 0] := 4;
  332.         running[12, 0, 1] := 0;
  333.         running[13, 0, 0] := 11;
  334.         running[13, 0, 1] := 1;
  335.         running[14, 0, 0] := 12;
  336.         running[14, 0, 1] := 1;
  337.         running[15, 0, 0] := 13;
  338.         running[15, 0, 1] := 1;
  339.         running[16, 0, 0] := 14;
  340.         running[16, 0, 1] := 1;
  341.  
  342.         for index := -16 to 16 do
  343.             begin
  344.                 running[index, 1, 0] := -running[-index, 0, 0];
  345.                 running[index, 1, 1] := running[-index, 0, 1];
  346.             end;
  347.  
  348.         for index := 2 to 16 do
  349.             begin
  350.                 idleLanded[index] := index - 2;
  351.                 idleLanded[-index] := -index + 2;
  352.             end;
  353.         idleLanded[-1] := 0;
  354.         idleLanded[0] := 0;
  355.         idleLanded[1] := 0;
  356.  
  357.         for index := -16 to -1 do
  358.             begin
  359.                 gliding[index, 0] := index + 3;
  360.                 gliding[-index, 1] := -index - 3;
  361.             end;
  362.  
  363.         for index := 0 to 14 do
  364.             begin
  365.                 gliding[index, 0] := index + 2;
  366.                 gliding[-index, 1] := -index - 2;
  367.             end;
  368.  
  369.         gliding[16, 0] := 16;
  370.         gliding[-16, 1] := -16;
  371.         gliding[15, 0] := 16;
  372.         gliding[-15, 1] := -16;
  373.  
  374.         for index := -70 to 16 do
  375.             begin
  376.                 impacted[index] := (-2 * index) div 3;
  377.             end;
  378.         SetRect(tombRects[-5], -70, 317, 167, 343);
  379.         SetRect(tombRects[-4], 346, 317, 583, 343);
  380.         SetRect(tombRects[-3], 201, 145, 312, 162);
  381.         SetRect(tombRects[-2], 167, 317, 346, 343);
  382.         SetRect(tombRects[-1], -70, 317, 583, 343);
  383.         SetRect(tombRects[0], 167, 317, 346, 343);
  384.         SetRect(tombRects[1], -70, 211, 110, 226);
  385.         SetRect(tombRects[2], 403, 211, 583, 226);
  386.         SetRect(tombRects[3], -70, 95, 134, 110);
  387.         SetRect(tombRects[4], 379, 95, 583, 110);
  388.         SetRect(tombRects[5], 201, 145, 312, 162);
  389.         SetRect(tombRects[6], -70, 317, 167, 343);
  390.  
  391.         SetRect(eyeRects[0], 465, 0, 512, 33);
  392.         SetRect(eyeRects[1], 417, 0, 464, 33);
  393.         SetRect(eyeRects[2], 370, 0, 417, 33);
  394.         SetRect(eyeRects[3], 323, 0, 370, 33);
  395.         SetRect(eyeRects[4], 276, 0, 323, 33);
  396.         SetRect(eyeRects[5], 465, 33, 512, 66);    {eye mask Rects follow}
  397.         SetRect(eyeRects[6], 417, 33, 464, 66);
  398.         SetRect(eyeRects[7], 370, 33, 417, 66);
  399.         SetRect(eyeRects[8], 323, 33, 370, 66);
  400.         SetRect(eyeRects[9], 276, 33, 323, 66);
  401.  
  402.         with theEye do
  403.             begin
  404.                 dest := eyeRects[4];
  405.                 OffsetRect(dest, -43, 70);
  406.                 oldDest := dest;
  407.             end;
  408.  
  409.         SetRect(eggRects[0], 410, 164, 432, 186);
  410.         SetRect(eggRects[1], 434, 164, 456, 186);
  411.  
  412.         SetRect(flameRect[0], 44, 226, 71, 275);
  413.         SetRect(flameRect[1], 445, 226, 472, 275);
  414.  
  415.         SetRect(littleTombRect, 260, 266, 371, 283);
  416.         SetRect(upperTombRect1, 0, 265, 135, 281);
  417.         SetRect(upperTombRect2, 136, 265, 271, 281);
  418.  
  419.         SetRect(scoreGrabRect, 373, 266, 509, 283);
  420.         SetRect(scoreDropRect, 189, 166, 325, 183);
  421.  
  422.         SetRect(gameoverRects[0], 274, 189, 456, 224);
  423.         SetRect(gameoverRects[1], 274, 225, 456, 261);
  424.  
  425.         SetRect(playRect, 12, 37, 500, 322);
  426.  
  427.         MoveTo(0, 0);
  428.         playRgn := NewRgn;
  429.         OpenRgn;
  430.         LineTo(0, 339);
  431.         LineTo(122, 339);
  432.         LineTo(122, 161);
  433.         LineTo(133, 141);
  434.         LineTo(144, 161);
  435.         LineTo(144, 339);
  436.         LineTo(369, 339);
  437.         LineTo(369, 161);
  438.         LineTo(380, 141);
  439.         LineTo(391, 161);
  440.         LineTo(391, 339);
  441.         LineTo(512, 339);
  442.         LineTo(512, 0);
  443.         LineTo(0, 0);
  444.         CloseRgn(playRgn);
  445.         HLock(Handle(playRgn));
  446.  
  447.         MoveTo(122, 339);
  448.         obeliskRgn1 := NewRgn;
  449.         OpenRgn;
  450.         LineTo(122, 161);
  451.         LineTo(133, 141);
  452.         LineTo(144, 161);
  453.         LineTo(144, 339);
  454.         LineTo(122, 339);
  455.         CloseRgn(obeliskRgn1);
  456.         HLock(Handle(obeliskRgn1));
  457.  
  458.         MoveTo(369, 339);
  459.         obeliskRgn2 := NewRgn;
  460.         OpenRgn;
  461.         LineTo(369, 161);
  462.         LineTo(380, 141);
  463.         LineTo(391, 161);
  464.         LineTo(391, 339);
  465.         LineTo(369, 339);
  466.         CloseRgn(obeliskRgn2);
  467.         HLock(Handle(obeliskRgn2));
  468.  
  469.         theSnd := GetNamedResource('snd ', 'ahnk.snd');
  470.         theSnd := GetNamedResource('snd ', 'bird.snd');
  471.         theSnd := GetNamedResource('snd ', 'bonus.snd');
  472.         theSnd := GetNamedResource('snd ', 'boom1.snd');
  473.         theSnd := GetNamedResource('snd ', 'boom2.snd');
  474.         theSnd := GetNamedResource('snd ', 'drip.snd');
  475.         theSnd := GetNamedResource('snd ', 'flap.snd');
  476.         theSnd := GetNamedResource('snd ', 'flip.snd');
  477.         theSnd := GetNamedResource('snd ', 'music.snd');
  478.         theSnd := GetNamedResource('snd ', 'rez.snd');
  479.         theSnd := GetNamedResource('snd ', 'screech.snd');
  480.         theSnd := GetNamedResource('snd ', 'spawn.snd');
  481.         theSnd := GetNamedResource('snd ', 'walk.snd');
  482.         theSnd := GetNamedResource('snd ', 'lightning.snd');
  483.     end;
  484.  
  485. {=================================}
  486.  
  487. end.